package multithread.thread.mychongrusuo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * Created by xi on 2019/2/17.
 * 这个代码只是单独的锁，没有做那种重入锁的功能
 */
public class MyLock implements Lock {


    private boolean isLocked = false; //锁的标记，锁被那个线程锁着呢

    //要实现的功能，lock的时候，只有一个线程能拿到锁，其他线程等待，然后等第一个unlock了，其他线程恢复
    //lock，synchorinize,wait, 第一个线程不等待，其他线程都等待。
    // 1 只能允许一个线程执行 这个函数，这个时候，我们要使用synchronized，其他线程都堵塞住
    // 2 只有一个线程能通过，其他线程要等待wait wait,必须在synchorinzed快里面，公用通一个监视器对象。

    @Override
    public synchronized  void lock() {
        //来到这个线程，都等待，只有初始进来的不等待，其他的都等待
        while(isLocked){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isLocked = true;
    }

    @Override
    public synchronized void unlock() {
            isLocked = false;
            notify(); //通知其他线程恢复
    }

    @Override public void lockInterruptibly() throws InterruptedException {

    }

    @Override public boolean tryLock() {
        return false;
    }

    @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }


    @Override public Condition newCondition() {
        return null;
    }
}
